home *** CD-ROM | disk | FTP | other *** search
/ Champak 125 / Vol 125 (Damaged).iso / games / stuff_se.swf / scripts / DefineSprite_70 / frame_10 / DoAction.as
Encoding:
Text File  |  2008-11-13  |  98.6 KB  |  2,027 lines

  1. var ┬º\x01┬º = 661;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 661)
  6.    {
  7.       set("\x01",eval("\x01") + 105);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 800)
  12.    {
  13.       set("\x01",eval("\x01") + 41);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 444)
  17.    {
  18.       set("\x01",eval("\x01") + 228);
  19.       continue;
  20.    }
  21.    if(eval("\x01") == 219)
  22.    {
  23.       set("\x01",eval("\x01") + 441);
  24.       break;
  25.    }
  26.    if(eval("\x01") == 841)
  27.    {
  28.       set("\x01",eval("\x01") - 823);
  29.       ┬º┬ºpush(true);
  30.       continue;
  31.    }
  32.    if(eval("\x01") == 418)
  33.    {
  34.       set("\x01",eval("\x01") - 177);
  35.       break;
  36.    }
  37.    if(eval("\x01") == 241)
  38.    {
  39.       set("\x01",eval("\x01") + 332);
  40.       continue;
  41.    }
  42.    if(eval("\x01") == 456)
  43.    {
  44.       set("\x01",eval("\x01") + 157);
  45.       if(┬º┬ºpop())
  46.       {
  47.          set("\x01",eval("\x01") + 187);
  48.       }
  49.       continue;
  50.    }
  51.    if(eval("\x01") == 254)
  52.    {
  53.       set("\x01",eval("\x01") + 164);
  54.       if(┬º┬ºpop())
  55.       {
  56.          set("\x01",eval("\x01") - 177);
  57.       }
  58.       continue;
  59.    }
  60.    if(eval("\x01") == 209)
  61.    {
  62.       set("\x01",eval("\x01") + 45);
  63.       ┬º┬ºpush(true);
  64.       continue;
  65.    }
  66.    if(eval("\x01") == 766)
  67.    {
  68.       set("\x01",eval("\x01") - 547);
  69.       if(┬º┬ºpop())
  70.       {
  71.          set("\x01",eval("\x01") + 441);
  72.       }
  73.       continue;
  74.    }
  75.    if(eval("\x01") == 527)
  76.    {
  77.       set("\x01",eval("\x01") + 145);
  78.       continue;
  79.    }
  80.    if(eval("\x01") == 199)
  81.    {
  82.       set("\x01",eval("\x01") + 374);
  83.       continue;
  84.    }
  85.    if(eval("\x01") == 77)
  86.    {
  87.       set("\x01",eval("\x01") + 132);
  88.       continue;
  89.    }
  90.    if(eval("\x01") == 93)
  91.    {
  92.       set("\x01",eval("\x01") + 265);
  93.       continue;
  94.    }
  95.    if(eval("\x01") != 146)
  96.    {
  97.       if(eval("\x01") == 368)
  98.       {
  99.          set("\x01",eval("\x01") + 473);
  100.       }
  101.       else if(eval("\x01") == 12)
  102.       {
  103.          set("\x01",eval("\x01") + 734);
  104.       }
  105.       else if(eval("\x01") == 500)
  106.       {
  107.          set("\x01",eval("\x01") - 291);
  108.       }
  109.       else
  110.       {
  111.          if(eval("\x01") != 573)
  112.          {
  113.             if(eval("\x01") == 651)
  114.             {
  115.                set("\x01",eval("\x01") - 565);
  116.                _root.SFX.gotoAndPlay("BootyUp");
  117.                stop();
  118.                break;
  119.             }
  120.             if(eval("\x01") == 383)
  121.             {
  122.                set("\x01",eval("\x01") - 116);
  123.             }
  124.             else
  125.             {
  126.                if(eval("\x01") == 631)
  127.                {
  128.                   set("\x01",eval("\x01") + 352);
  129.                   continue;
  130.                }
  131.                if(eval("\x01") == 403)
  132.                {
  133.                   set("\x01",eval("\x01") + 97);
  134.                   play();
  135.                   ┬º┬ºpush(┬º┬ºpop() == ┬º┬ºpop());
  136.                   break;
  137.                }
  138.                if(eval("\x01") == 613)
  139.                {
  140.                   set("\x01",eval("\x01") + 187);
  141.                   break;
  142.                }
  143.                if(eval("\x01") == 660)
  144.                {
  145.                   set("\x01",eval("\x01") + 323);
  146.                   continue;
  147.                }
  148.                if(eval("\x01") != 692)
  149.                {
  150.                   if(eval("\x01") == 217)
  151.                   {
  152.                      set("\x01",eval("\x01") + 475);
  153.                      if(┬º┬ºpop())
  154.                      {
  155.                         set("\x01",eval("\x01") + 68);
  156.                      }
  157.                   }
  158.                   else if(eval("\x01") == 785)
  159.                   {
  160.                      set("\x01",eval("\x01") - 639);
  161.                      if(┬º┬ºpop())
  162.                      {
  163.                         set("\x01",eval("\x01") + 463);
  164.                      }
  165.                   }
  166.                   else if(eval("\x01") == 567)
  167.                   {
  168.                      set("\x01",eval("\x01") - 164);
  169.                      if(┬º┬ºpop())
  170.                      {
  171.                         set("\x01",eval("\x01") + 97);
  172.                      }
  173.                   }
  174.                   else if(eval("\x01") == 746)
  175.                   {
  176.                      set("\x01",eval("\x01") - 179);
  177.                      ┬º┬ºpush(true);
  178.                   }
  179.                   else if(eval("\x01") == 983)
  180.                   {
  181.                      set("\x01",eval("\x01") - 198);
  182.                      ┬º┬ºpush(true);
  183.                   }
  184.                   else if(eval("\x01") == 609)
  185.                   {
  186.                      set("\x01",eval("\x01") + 137);
  187.                   }
  188.                   else if(eval("\x01") == 18)
  189.                   {
  190.                      set("\x01",eval("\x01") + 267);
  191.                      if(┬º┬ºpop())
  192.                      {
  193.                         set("\x01",eval("\x01") + 242);
  194.                      }
  195.                   }
  196.                   else
  197.                   {
  198.                      if(eval("\x01") == 285)
  199.                      {
  200.                         set("\x01",eval("\x01") + 242);
  201.                         prevFrame();
  202.                         break;
  203.                      }
  204.                      if(eval("\x01") == 672)
  205.                      {
  206.                         set("\x01",eval("\x01") + 183);
  207.                         ┬º┬ºpush(true);
  208.                      }
  209.                      else if(eval("\x01") == 855)
  210.                      {
  211.                         set("\x01",eval("\x01") - 472);
  212.                         if(┬º┬ºpop())
  213.                         {
  214.                            set("\x01",eval("\x01") - 116);
  215.                         }
  216.                      }
  217.                      else if(eval("\x01") == 267)
  218.                      {
  219.                         set("\x01",eval("\x01") + 91);
  220.                      }
  221.                      else if(eval("\x01") == 358)
  222.                      {
  223.                         set("\x01",eval("\x01") - 141);
  224.                         ┬º┬ºpush(true);
  225.                      }
  226.                      else if(eval("\x01") == 760)
  227.                      {
  228.                         set("\x01",eval("\x01") - 109);
  229.                      }
  230.                      else
  231.                      {
  232.                         if(eval("\x01") != 778)
  233.                         {
  234.                            if(eval("\x01") == 86)
  235.                            {
  236.                               set("\x01",eval("\x01") - 86);
  237.                            }
  238.                            break;
  239.                         }
  240.                         set("\x01",eval("\x01") - 127);
  241.                      }
  242.                   }
  243.                   continue;
  244.                }
  245.                set("\x01",eval("\x01") + 68);
  246.                stop();
  247.                while(true)
  248.                {
  249.                   if(eval("\x01") == 756)
  250.                   {
  251.                      set("\x01",eval("\x01") + 114);
  252.                      ┬º┬ºpush(true);
  253.                      continue;
  254.                   }
  255.                   if(eval("\x01") == 176)
  256.                   {
  257.                      set("\x01",eval("\x01") + 483);
  258.                      if(┬º┬ºpop())
  259.                      {
  260.                         set("\x01",eval("\x01") + 37);
  261.                      }
  262.                      continue;
  263.                   }
  264.                   if(eval("\x01") == 276)
  265.                   {
  266.                      set("\x01",eval("\x01") + 61);
  267.                      ┬º┬ºgoto(addr1833);
  268.                   }
  269.                   else
  270.                   {
  271.                      if(eval("\x01") == 305)
  272.                      {
  273.                         set("\x01",eval("\x01") - 29);
  274.                         if(┬º┬ºpop())
  275.                         {
  276.                            set("\x01",eval("\x01") + 61);
  277.                         }
  278.                         continue;
  279.                      }
  280.                      if(eval("\x01") == 229)
  281.                      {
  282.                         set("\x01",eval("\x01") + 592);
  283.                         if(┬º┬ºpop())
  284.                         {
  285.                            set("\x01",eval("\x01") - 66);
  286.                         }
  287.                         continue;
  288.                      }
  289.                      if(eval("\x01") == 337)
  290.                      {
  291.                         set("\x01",eval("\x01") + 661);
  292.                         continue;
  293.                      }
  294.                      if(eval("\x01") == 482)
  295.                      {
  296.                         set("\x01",eval("\x01") - 334);
  297.                         if(┬º┬ºpop())
  298.                         {
  299.                            set("\x01",eval("\x01") + 558);
  300.                         }
  301.                         continue;
  302.                      }
  303.                      if(eval("\x01") == 814)
  304.                      {
  305.                         set("\x01",eval("\x01") - 585);
  306.                         ┬º┬ºpush(true);
  307.                         continue;
  308.                      }
  309.                      if(eval("\x01") == 636)
  310.                      {
  311.                         set("\x01",eval("\x01") + 236);
  312.                         if(eval("\t") != 1)
  313.                         {
  314.                            gotoAndStop("{invalid_utf8=232}");
  315.                         }
  316.                         break loop0;
  317.                      }
  318.                      if(eval("\x01") == 821)
  319.                      {
  320.                         set("\x01",eval("\x01") - 66);
  321.                         break loop0;
  322.                      }
  323.                      if(eval("\x01") == 533)
  324.                      {
  325.                         set("\x01",eval("\x01") - 498);
  326.                         continue;
  327.                      }
  328.                      if(eval("\x01") == 659)
  329.                      {
  330.                         set("\x01",eval("\x01") + 37);
  331.                         loop4:
  332.                         while(true)
  333.                         {
  334.                            set(┬º┬ºpop(),┬º┬ºpop());
  335.                            loop5:
  336.                            while(true)
  337.                            {
  338.                               while(true)
  339.                               {
  340.                                  if(eval("\x01") == 98)
  341.                                  {
  342.                                     set("\x01",eval("\x01") + 351);
  343.                                     ┬º┬ºpush(true);
  344.                                     continue;
  345.                                  }
  346.                                  if(eval("\x01") == 684)
  347.                                  {
  348.                                     set("\x01",eval("\x01") + 154);
  349.                                     continue;
  350.                                  }
  351.                                  if(eval("\x01") == 282)
  352.                                  {
  353.                                     set("\x01",eval("\x01") + 402);
  354.                                     break loop0;
  355.                                  }
  356.                                  if(eval("\x01") == 749)
  357.                                  {
  358.                                     set("\x01",eval("\x01") - 570);
  359.                                     ┬º┬ºpush(true);
  360.                                     continue;
  361.                                  }
  362.                                  if(eval("\x01") == 313)
  363.                                  {
  364.                                     set("\x01",eval("\x01") + 504);
  365.                                     break loop0;
  366.                                  }
  367.                                  if(eval("\x01") == 977)
  368.                                  {
  369.                                     set("\x01",eval("\x01") - 228);
  370.                                     continue;
  371.                                  }
  372.                                  if(eval("\x01") == 449)
  373.                                  {
  374.                                     set("\x01",eval("\x01") - 131);
  375.                                     if(┬º┬ºpop())
  376.                                     {
  377.                                        set("\x01",eval("\x01") + 222);
  378.                                     }
  379.                                     continue;
  380.                                  }
  381.                                  if(eval("\x01") == 744)
  382.                                  {
  383.                                     set("\x01",eval("\x01") - 147);
  384.                                     ┬º┬ºpush(true);
  385.                                     continue;
  386.                                  }
  387.                                  if(eval("\x01") == 889)
  388.                                  {
  389.                                     set("\x01",eval("\x01") - 609);
  390.                                     continue;
  391.                                  }
  392.                                  if(eval("\x01") == 483)
  393.                                  {
  394.                                     set("\x01",eval("\x01") + 83);
  395.                                     break loop0;
  396.                                  }
  397.                                  if(eval("\x01") == 657)
  398.                                  {
  399.                                     set("\x01",eval("\x01") - 375);
  400.                                     if(┬º┬ºpop())
  401.                                     {
  402.                                        set("\x01",eval("\x01") + 402);
  403.                                     }
  404.                                     continue;
  405.                                  }
  406.                                  if(eval("\x01") == 405)
  407.                                  {
  408.                                     set("\x01",eval("\x01") - 212);
  409.                                     continue;
  410.                                  }
  411.                                  if(eval("\x01") == 614)
  412.                                  {
  413.                                     set("\x01",eval("\x01") - 131);
  414.                                     if(┬º┬ºpop())
  415.                                     {
  416.                                        set("\x01",eval("\x01") + 83);
  417.                                     }
  418.                                     continue;
  419.                                  }
  420.                                  if(eval("\x01") == 797)
  421.                                  {
  422.                                     set("\x01",eval("\x01") + 141);
  423.                                     continue;
  424.                                  }
  425.                                  if(eval("\x01") == 566)
  426.                                  {
  427.                                     set("\x01",eval("\x01") + 183);
  428.                                     continue;
  429.                                  }
  430.                                  if(eval("\x01") == 838)
  431.                                  {
  432.                                     set("\x01",eval("\x01") - 224);
  433.                                     ┬º┬ºpush(true);
  434.                                     continue;
  435.                                  }
  436.                                  if(eval("\x01") == 28)
  437.                                  {
  438.                                     set("\x01",eval("\x01") + 252);
  439.                                     continue;
  440.                                  }
  441.                                  if(eval("\x01") == 861)
  442.                                  {
  443.                                     set("\x01",eval("\x01") - 23);
  444.                                     continue;
  445.                                  }
  446.                                  if(eval("\x01") == 597)
  447.                                  {
  448.                                     set("\x01",eval("\x01") + 187);
  449.                                     if(┬º┬ºpop())
  450.                                     {
  451.                                        set("\x01",eval("\x01") - 710);
  452.                                     }
  453.                                     continue;
  454.                                  }
  455.                                  if(eval("\x01") == 877)
  456.                                  {
  457.                                     break loop5;
  458.                                  }
  459.                                  if(eval("\x01") == 938)
  460.                                  {
  461.                                     set("\x01",eval("\x01") - 281);
  462.                                     ┬º┬ºpush(true);
  463.                                     continue;
  464.                                  }
  465.                                  if(eval("\x01") == 193)
  466.                                  {
  467.                                     set("\x01",eval("\x01") + 445);
  468.                                     ┬º┬ºpush(true);
  469.                                     continue;
  470.                                  }
  471.                                  if(eval("\x01") == 540)
  472.                                  {
  473.                                     set("\x01",eval("\x01") + 398);
  474.                                     continue;
  475.                                  }
  476.                                  if(eval("\x01") == 280)
  477.                                  {
  478.                                     set("\x01",eval("\x01") + 77);
  479.                                     gotoAndPlay(_root.randInt(1,this._totalframes));
  480.                                     break loop0;
  481.                                  }
  482.                                  if(eval("\x01") == 74)
  483.                                  {
  484.                                     set("\x01",eval("\x01") + 119);
  485.                                     continue;
  486.                                  }
  487.                                  if(eval("\x01") != 784)
  488.                                  {
  489.                                     if(eval("\x01") == 638)
  490.                                     {
  491.                                        break;
  492.                                     }
  493.                                     if(eval("\x01") == 179)
  494.                                     {
  495.                                        set("\x01",eval("\x01") + 134);
  496.                                        if(┬º┬ºpop())
  497.                                        {
  498.                                           set("\x01",eval("\x01") + 504);
  499.                                        }
  500.                                     }
  501.                                     else
  502.                                     {
  503.                                        if(eval("\x01") == 318)
  504.                                        {
  505.                                           set("\x01",eval("\x01") + 222);
  506.                                           break loop0;
  507.                                        }
  508.                                        if(eval("\x01") == 817)
  509.                                        {
  510.                                           set("\x01",eval("\x01") - 73);
  511.                                        }
  512.                                        else
  513.                                        {
  514.                                           if(eval("\x01") != 365)
  515.                                           {
  516.                                              if(eval("\x01") == 357)
  517.                                              {
  518.                                                 set("\x01",eval("\x01") - 357);
  519.                                              }
  520.                                              break loop0;
  521.                                           }
  522.                                           set("\x01",eval("\x01") + 379);
  523.                                        }
  524.                                     }
  525.                                     continue;
  526.                                  }
  527.                                  set("\x01",eval("\x01") - 710);
  528.                                  loop7:
  529.                                  while(true)
  530.                                  {
  531.                                     set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  532.                                     loop8:
  533.                                     while(true)
  534.                                     {
  535.                                        while(true)
  536.                                        {
  537.                                           if(eval("\x01") == 285)
  538.                                           {
  539.                                              set("\x01",eval("\x01") - 19);
  540.                                              ┬º┬ºpush(true);
  541.                                           }
  542.                                           else if(eval("\x01") == 830)
  543.                                           {
  544.                                              set("\x01",eval("\x01") - 426);
  545.                                              ┬º┬ºpush(true);
  546.                                           }
  547.                                           else if(eval("\x01") == 382)
  548.                                           {
  549.                                              set("\x01",eval("\x01") + 485);
  550.                                              ┬º┬ºpush(true);
  551.                                           }
  552.                                           else if(eval("\x01") == 666)
  553.                                           {
  554.                                              set("\x01",eval("\x01") - 150);
  555.                                           }
  556.                                           else if(eval("\x01") == 910)
  557.                                           {
  558.                                              set("\x01",eval("\x01") - 80);
  559.                                           }
  560.                                           else
  561.                                           {
  562.                                              if(eval("\x01") == 742)
  563.                                              {
  564.                                                 set("\x01",eval("\x01") - 670);
  565.                                                 break loop0;
  566.                                              }
  567.                                              if(eval("\x01") == 738)
  568.                                              {
  569.                                                 set("\x01",eval("\x01") - 69);
  570.                                                 if(┬º┬ºpop())
  571.                                                 {
  572.                                                    set("\x01",eval("\x01") - 45);
  573.                                                 }
  574.                                              }
  575.                                              else if(eval("\x01") == 96)
  576.                                              {
  577.                                                 set("\x01",eval("\x01") + 547);
  578.                                                 ┬º┬ºpush(true);
  579.                                              }
  580.                                              else if(eval("\x01") == 248)
  581.                                              {
  582.                                                 set("\x01",eval("\x01") + 704);
  583.                                                 if(┬º┬ºpop())
  584.                                                 {
  585.                                                    set("\x01",eval("\x01") - 427);
  586.                                                 }
  587.                                              }
  588.                                              else if(eval("\x01") == 682)
  589.                                              {
  590.                                                 set("\x01",eval("\x01") + 266);
  591.                                              }
  592.                                              else
  593.                                              {
  594.                                                 if(eval("\x01") == 163)
  595.                                                 {
  596.                                                    set("\x01",eval("\x01") + 733);
  597.                                                    removeMovieClip(┬º┬ºpop());
  598.                                                    toggleHighQuality();
  599.                                                    ┬º┬ºpush(new ┬ºord(\┬º\┬ºpop())┬º());
  600.                                                    break loop0;
  601.                                                 }
  602.                                                 if(eval("\x01") == 97)
  603.                                                 {
  604.                                                    break loop8;
  605.                                                 }
  606.                                                 if(eval("\x01") == 826)
  607.                                                 {
  608.                                                    set("\x01",eval("\x01") + 4);
  609.                                                 }
  610.                                                 else if(eval("\x01") == 161)
  611.                                                 {
  612.                                                    set("\x01",eval("\x01") + 806);
  613.                                                    if(┬º┬ºpop())
  614.                                                    {
  615.                                                       set("\x01",eval("\x01") - 770);
  616.                                                    }
  617.                                                 }
  618.                                                 else if(eval("\x01") == 440)
  619.                                                 {
  620.                                                    set("\x01",eval("\x01") - 343);
  621.                                                    if(┬º┬ºpop())
  622.                                                    {
  623.                                                       set("\x01",eval("\x01") + 439);
  624.                                                    }
  625.                                                 }
  626.                                                 else if(eval("\x01") == 323)
  627.                                                 {
  628.                                                    set("\x01",eval("\x01") + 49);
  629.                                                 }
  630.                                                 else if(eval("\x01") == 643)
  631.                                                 {
  632.                                                    set("\x01",eval("\x01") - 480);
  633.                                                    if(┬º┬ºpop())
  634.                                                    {
  635.                                                       set("\x01",eval("\x01") + 733);
  636.                                                    }
  637.                                                 }
  638.                                                 else
  639.                                                 {
  640.                                                    if(eval("\x01") == 468)
  641.                                                    {
  642.                                                       set("\x01",eval("\x01") + 358);
  643.                                                       prevFrame();
  644.                                                       break loop0;
  645.                                                    }
  646.                                                    if(eval("\x01") == 266)
  647.                                                    {
  648.                                                       set("\x01",eval("\x01") + 607);
  649.                                                       if(┬º┬ºpop())
  650.                                                       {
  651.                                                          set("\x01",eval("\x01") + 82);
  652.                                                       }
  653.                                                    }
  654.                                                    else if(eval("\x01") == 990)
  655.                                                    {
  656.                                                       set("\x01",eval("\x01") - 829);
  657.                                                       ┬º┬ºpush(true);
  658.                                                    }
  659.                                                    else
  660.                                                    {
  661.                                                       if(eval("\x01") == 873)
  662.                                                       {
  663.                                                          set("\x01",eval("\x01") + 82);
  664.                                                          break loop0;
  665.                                                       }
  666.                                                       if(eval("\x01") == 346)
  667.                                                       {
  668.                                                          set("\x01",eval("\x01") - 250);
  669.                                                       }
  670.                                                       else if(eval("\x01") == 65)
  671.                                                       {
  672.                                                          set("\x01",eval("\x01") + 403);
  673.                                                          if(┬º┬ºpop())
  674.                                                          {
  675.                                                             set("\x01",eval("\x01") + 358);
  676.                                                          }
  677.                                                       }
  678.                                                       else if(eval("\x01") == 536)
  679.                                                       {
  680.                                                          set("\x01",eval("\x01") - 440);
  681.                                                       }
  682.                                                       else if(eval("\x01") == 516)
  683.                                                       {
  684.                                                          set("\x01",eval("\x01") - 451);
  685.                                                          ┬º┬ºpush(true);
  686.                                                       }
  687.                                                       else if(eval("\x01") == 955)
  688.                                                       {
  689.                                                          set("\x01",eval("\x01") - 54);
  690.                                                       }
  691.                                                       else if(eval("\x01") == 197)
  692.                                                       {
  693.                                                          set("\x01",eval("\x01") + 319);
  694.                                                       }
  695.                                                       else if(eval("\x01") == 525)
  696.                                                       {
  697.                                                          set("\x01",eval("\x01") - 143);
  698.                                                       }
  699.                                                       else if(eval("\x01") == 441)
  700.                                                       {
  701.                                                          set("\x01",eval("\x01") + 549);
  702.                                                       }
  703.                                                       else if(eval("\x01") == 50)
  704.                                                       {
  705.                                                          set("\x01",eval("\x01") + 198);
  706.                                                          ┬º┬ºpush(true);
  707.                                                       }
  708.                                                       else if(eval("\x01") == 59)
  709.                                                       {
  710.                                                          set("\x01",eval("\x01") + 313);
  711.                                                       }
  712.                                                       else if(eval("\x01") == 867)
  713.                                                       {
  714.                                                          set("\x01",eval("\x01") - 25);
  715.                                                          if(┬º┬ºpop())
  716.                                                          {
  717.                                                             set("\x01",eval("\x01") - 626);
  718.                                                          }
  719.                                                       }
  720.                                                       else
  721.                                                       {
  722.                                                          if(eval("\x01") == 355)
  723.                                                          {
  724.                                                             set("\x01",eval("\x01") - 296);
  725.                                                             break loop0;
  726.                                                          }
  727.                                                          if(eval("\x01") == 404)
  728.                                                          {
  729.                                                             set("\x01",eval("\x01") + 338);
  730.                                                             if(┬º┬ºpop())
  731.                                                             {
  732.                                                                set("\x01",eval("\x01") - 670);
  733.                                                             }
  734.                                                          }
  735.                                                          else if(eval("\x01") == 896)
  736.                                                          {
  737.                                                             set("\x01",eval("\x01") + 94);
  738.                                                          }
  739.                                                          else
  740.                                                          {
  741.                                                             if(eval("\x01") == 967)
  742.                                                             {
  743.                                                                set("\x01",eval("\x01") - 770);
  744.                                                                ┬º┬ºpush(┬º┬ºpop() + ┬º┬ºpop()[┬º┬ºpop() > ┬º┬ºpop() >>> ┬º┬ºpop()]);
  745.                                                                break loop0;
  746.                                                             }
  747.                                                             if(eval("\x01") == 901)
  748.                                                             {
  749.                                                                set("\x01",eval("\x01") - 461);
  750.                                                                ┬º┬ºpush(true);
  751.                                                             }
  752.                                                             else if(eval("\x01") == 372)
  753.                                                             {
  754.                                                                set("\x01",eval("\x01") + 366);
  755.                                                                ┬º┬ºpush(true);
  756.                                                             }
  757.                                                             else if(eval("\x01") == 72)
  758.                                                             {
  759.                                                                set("\x01",eval("\x01") - 22);
  760.                                                             }
  761.                                                             else if(eval("\x01") == 708)
  762.                                                             {
  763.                                                                set("\x01",eval("\x01") - 648);
  764.                                                             }
  765.                                                             else if(eval("\x01") == 517)
  766.                                                             {
  767.                                                                set("\x01",eval("\x01") - 467);
  768.                                                             }
  769.                                                             else if(eval("\x01") == 511)
  770.                                                             {
  771.                                                                set("\x01",eval("\x01") + 390);
  772.                                                             }
  773.                                                             else
  774.                                                             {
  775.                                                                if(eval("\x01") == 952)
  776.                                                                {
  777.                                                                   set("\x01",eval("\x01") - 427);
  778.                                                                   stop();
  779.                                                                   ┬º┬ºpush(int(delete ┬º┬ºpop()));
  780.                                                                   break loop0;
  781.                                                                }
  782.                                                                if(eval("\x01") == 842)
  783.                                                                {
  784.                                                                   set("\x01",eval("\x01") - 626);
  785.                                                                   ┬º┬ºpop() extends ┬º┬ºpop();
  786.                                                                   ┬º┬ºpush(int(┬º┬ºpop()));
  787.                                                                   break loop0;
  788.                                                                }
  789.                                                                if(eval("\x01") == 438)
  790.                                                                {
  791.                                                                   set("\x01",eval("\x01") - 56);
  792.                                                                }
  793.                                                                else if(eval("\x01") == 216)
  794.                                                                {
  795.                                                                   set("\x01",eval("\x01") - 156);
  796.                                                                }
  797.                                                                else if(eval("\x01") == 60)
  798.                                                                {
  799.                                                                   set("\x01",eval("\x01") + 433);
  800.                                                                   ┬º┬ºpush(true);
  801.                                                                }
  802.                                                                else
  803.                                                                {
  804.                                                                   if(eval("\x01") == 493)
  805.                                                                   {
  806.                                                                      break;
  807.                                                                   }
  808.                                                                   if(eval("\x01") == 669)
  809.                                                                   {
  810.                                                                      set("\x01",eval("\x01") - 45);
  811.                                                                      break loop0;
  812.                                                                   }
  813.                                                                   if(eval("\x01") == 624)
  814.                                                                   {
  815.                                                                      set("\x01",eval("\x01") + 58);
  816.                                                                   }
  817.                                                                   else
  818.                                                                   {
  819.                                                                      if(eval("\x01") == 948)
  820.                                                                      {
  821.                                                                         set("\x01",eval("\x01") - 43);
  822.                                                                         eval("{{invalid_utf8=128}{invalid_utf8=231}+\x05.")["j{invalid_utf8=150}s{invalid_utf8=190}"] = eval("{{invalid_utf8=128}{invalid_utf8=231}+\x05.")["I{invalid_utf8=157}{invalid_utf8=185}{invalid_utf8=250}"];
  823.                                                                         stop();
  824.                                                                         break loop0;
  825.                                                                      }
  826.                                                                      if(eval("\x01") != 61)
  827.                                                                      {
  828.                                                                         if(eval("\x01") == 905)
  829.                                                                         {
  830.                                                                            set("\x01",eval("\x01") - 905);
  831.                                                                         }
  832.                                                                         break loop0;
  833.                                                                      }
  834.                                                                      set("\x01",eval("\x01") + 621);
  835.                                                                   }
  836.                                                                }
  837.                                                             }
  838.                                                          }
  839.                                                       }
  840.                                                    }
  841.                                                 }
  842.                                              }
  843.                                           }
  844.                                        }
  845.                                        set("\x01",eval("\x01") - 138);
  846.                                        if(!┬º┬ºpop())
  847.                                        {
  848.                                           continue;
  849.                                        }
  850.                                        continue loop7;
  851.                                     }
  852.                                     set("\x01",eval("\x01") + 439);
  853.                                     loop10:
  854.                                     while(true)
  855.                                     {
  856.                                        set(┬º┬ºpop(),eval("\x01") - 75);
  857.                                        loop11:
  858.                                        while(true)
  859.                                        {
  860.                                           while(true)
  861.                                           {
  862.                                              if(eval("\x01") == 994)
  863.                                              {
  864.                                                 set("\x01",eval("\x01") - 281);
  865.                                                 ┬º┬ºpush(true);
  866.                                              }
  867.                                              else if(eval("\x01") == 583)
  868.                                              {
  869.                                                 set("\x01",eval("\x01") + 194);
  870.                                              }
  871.                                              else if(eval("\x01") == 304)
  872.                                              {
  873.                                                 set("\x01",eval("\x01") + 24);
  874.                                              }
  875.                                              else if(eval("\x01") == 713)
  876.                                              {
  877.                                                 set("\x01",eval("\x01") - 371);
  878.                                                 if(┬º┬ºpop())
  879.                                                 {
  880.                                                    set("\x01",eval("\x01") - 208);
  881.                                                 }
  882.                                              }
  883.                                              else
  884.                                              {
  885.                                                 if(eval("\x01") == 658)
  886.                                                 {
  887.                                                    set("\x01",eval("\x01") - 75);
  888.                                                    break loop0;
  889.                                                 }
  890.                                                 if(eval("\x01") == 635)
  891.                                                 {
  892.                                                    set("\x01",eval("\x01") - 352);
  893.                                                    ┬º┬ºpush(true);
  894.                                                 }
  895.                                                 else if(eval("\x01") == 303)
  896.                                                 {
  897.                                                    set("\x01",eval("\x01") + 19);
  898.                                                    ┬º┬ºpush(true);
  899.                                                 }
  900.                                                 else
  901.                                                 {
  902.                                                    if(eval("\x01") == 501)
  903.                                                    {
  904.                                                       set("\x01",eval("\x01") - 228);
  905.                                                       prevFrame();
  906.                                                       break loop0;
  907.                                                    }
  908.                                                    if(eval("\x01") == 768)
  909.                                                    {
  910.                                                       set("\x01",eval("\x01") - 440);
  911.                                                    }
  912.                                                    else
  913.                                                    {
  914.                                                       if(eval("\x01") == 777)
  915.                                                       {
  916.                                                          break loop11;
  917.                                                       }
  918.                                                       if(eval("\x01") == 639)
  919.                                                       {
  920.                                                          set("\x01",eval("\x01") + 138);
  921.                                                       }
  922.                                                       else if(eval("\x01") == 328)
  923.                                                       {
  924.                                                          set("\x01",eval("\x01") + 315);
  925.                                                          ┬º┬ºpush(true);
  926.                                                       }
  927.                                                       else if(eval("\x01") == 273)
  928.                                                       {
  929.                                                          set("\x01",eval("\x01") + 98);
  930.                                                       }
  931.                                                       else
  932.                                                       {
  933.                                                          if(eval("\x01") == 194)
  934.                                                          {
  935.                                                             set("\x01",eval("\x01") + 574);
  936.                                                             ┬º┬ºpush(┬º┬ºpop() > ┬º┬ºpop());
  937.                                                             break loop0;
  938.                                                          }
  939.                                                          if(eval("\x01") == 478)
  940.                                                          {
  941.                                                             break;
  942.                                                          }
  943.                                                          if(eval("\x01") == 643)
  944.                                                          {
  945.                                                             set("\x01",eval("\x01") - 142);
  946.                                                             if(┬º┬ºpop())
  947.                                                             {
  948.                                                                set("\x01",eval("\x01") - 228);
  949.                                                             }
  950.                                                          }
  951.                                                          else if(eval("\x01") == 283)
  952.                                                          {
  953.                                                             set("\x01",eval("\x01") - 89);
  954.                                                             if(┬º┬ºpop())
  955.                                                             {
  956.                                                                set("\x01",eval("\x01") + 574);
  957.                                                             }
  958.                                                          }
  959.                                                          else if(eval("\x01") == 322)
  960.                                                          {
  961.                                                             set("\x01",eval("\x01") + 420);
  962.                                                             if(┬º┬ºpop())
  963.                                                             {
  964.                                                                set("\x01",eval("\x01") - 468);
  965.                                                             }
  966.                                                          }
  967.                                                          else if(eval("\x01") == 369)
  968.                                                          {
  969.                                                             set("\x01",eval("\x01") + 266);
  970.                                                          }
  971.                                                          else if(eval("\x01") == 371)
  972.                                                          {
  973.                                                             set("\x01",eval("\x01") + 107);
  974.                                                             ┬º┬ºpush(true);
  975.                                                          }
  976.                                                          else
  977.                                                          {
  978.                                                             if(eval("\x01") == 742)
  979.                                                             {
  980.                                                                set("\x01",eval("\x01") - 468);
  981.                                                                break loop0;
  982.                                                             }
  983.                                                             if(eval("\x01") == 932)
  984.                                                             {
  985.                                                                set("\x01",eval("\x01") - 629);
  986.                                                             }
  987.                                                             else
  988.                                                             {
  989.                                                                if(eval("\x01") == 471)
  990.                                                                {
  991.                                                                   set("\x01",eval("\x01") - 471);
  992.                                                                   break loop0;
  993.                                                                }
  994.                                                                if(eval("\x01") == 342)
  995.                                                                {
  996.                                                                   set("\x01",eval("\x01") - 208);
  997.                                                                   ┬º┬ºpush(┬º┬ºpop() or ┬º┬ºpop());
  998.                                                                   break loop0;
  999.                                                                }
  1000.                                                                if(eval("\x01") == 51)
  1001.                                                                {
  1002.                                                                   set("\x01",eval("\x01") + 320);
  1003.                                                                }
  1004.                                                                else if(eval("\x01") == 134)
  1005.                                                                {
  1006.                                                                   set("\x01",eval("\x01") + 169);
  1007.                                                                }
  1008.                                                                else
  1009.                                                                {
  1010.                                                                   if(eval("\x01") != 274)
  1011.                                                                   {
  1012.                                                                      break loop0;
  1013.                                                                   }
  1014.                                                                   set("\x01",eval("\x01") + 361);
  1015.                                                                }
  1016.                                                             }
  1017.                                                          }
  1018.                                                       }
  1019.                                                    }
  1020.                                                 }
  1021.                                              }
  1022.                                           }
  1023.                                           set("\x01",eval("\x01") + 180);
  1024.                                           if(!┬º┬ºpop())
  1025.                                           {
  1026.                                              continue;
  1027.                                           }
  1028.                                           continue loop10;
  1029.                                        }
  1030.                                        set("\x01",eval("\x01") - 306);
  1031.                                        Selection.setFocus("codeField");
  1032.                                        stop();
  1033.                                        break loop0;
  1034.                                     }
  1035.                                  }
  1036.                               }
  1037.                               set("\x01",eval("\x01") + 239);
  1038.                               if(!┬º┬ºpop())
  1039.                               {
  1040.                                  continue;
  1041.                               }
  1042.                               continue loop4;
  1043.                            }
  1044.                            set("\x01",eval("\x01") + 12);
  1045.                            break loop0;
  1046.                         }
  1047.                      }
  1048.                      else
  1049.                      {
  1050.                         if(eval("\x01") == 148)
  1051.                         {
  1052.                            set("\x01",eval("\x01") + 558);
  1053.                            break loop0;
  1054.                         }
  1055.                         if(eval("\x01") == 696)
  1056.                         {
  1057.                            set("\x01",eval("\x01") + 118);
  1058.                            continue;
  1059.                         }
  1060.                         if(eval("\x01") == 603)
  1061.                         {
  1062.                            set("\x01",eval("\x01") + 184);
  1063.                            continue;
  1064.                         }
  1065.                         if(eval("\x01") == 541)
  1066.                         {
  1067.                            set("\x01",eval("\x01") + 19);
  1068.                            continue;
  1069.                         }
  1070.                         if(eval("\x01") == 722)
  1071.                         {
  1072.                            set("\x01",eval("\x01") - 687);
  1073.                            continue;
  1074.                         }
  1075.                         if(eval("\x01") == 787)
  1076.                         {
  1077.                            set("\x01",eval("\x01") - 482);
  1078.                            ┬º┬ºpush(true);
  1079.                            continue;
  1080.                         }
  1081.                         if(eval("\x01") == 289)
  1082.                         {
  1083.                            set("\x01",eval("\x01") + 701);
  1084.                            continue;
  1085.                         }
  1086.                         if(eval("\x01") == 872)
  1087.                         {
  1088.                            set("\x01",eval("\x01") - 559);
  1089.                            continue;
  1090.                         }
  1091.                         if(eval("\x01") == 748)
  1092.                         {
  1093.                            set("\x01",eval("\x01") - 459);
  1094.                            break loop0;
  1095.                         }
  1096.                         if(eval("\x01") == 4)
  1097.                         {
  1098.                            set("\x01",eval("\x01") + 783);
  1099.                            continue;
  1100.                         }
  1101.                         if(eval("\x01") == 706)
  1102.                         {
  1103.                            set("\x01",eval("\x01") - 74);
  1104.                            continue;
  1105.                         }
  1106.                         if(eval("\x01") == 632)
  1107.                         {
  1108.                            set("\x01",eval("\x01") - 280);
  1109.                            stop();
  1110.                            break loop0;
  1111.                         }
  1112.                         if(eval("\x01") == 889)
  1113.                         {
  1114.                            set("\x01",eval("\x01") - 253);
  1115.                            set("\t",1);
  1116.                            continue;
  1117.                         }
  1118.                         if(eval("\x01") == 740)
  1119.                         {
  1120.                            set("\x01",eval("\x01") + 149);
  1121.                            if(┬º┬ºpop())
  1122.                            {
  1123.                               set("\x01",eval("\x01") - 885);
  1124.                            }
  1125.                            continue;
  1126.                         }
  1127.                         if(eval("\x01") == 990)
  1128.                         {
  1129.                            set("\x01",eval("\x01") - 250);
  1130.                            ┬º┬ºpush(true);
  1131.                            continue;
  1132.                         }
  1133.                         if(eval("\x01") == 441)
  1134.                         {
  1135.                            set("\x01",eval("\x01") + 557);
  1136.                            continue;
  1137.                         }
  1138.                         if(eval("\x01") == 907)
  1139.                         {
  1140.                            set("\x01",eval("\x01") - 275);
  1141.                            continue;
  1142.                         }
  1143.                         if(eval("\x01") == 95)
  1144.                         {
  1145.                            set("\x01",eval("\x01") + 895);
  1146.                            continue;
  1147.                         }
  1148.                         if(eval("\x01") == 313)
  1149.                         {
  1150.                            set("\x01",eval("\x01") + 328);
  1151.                            ┬º┬ºpush(true);
  1152.                            continue;
  1153.                         }
  1154.                         if(eval("\x01") == 870)
  1155.                         {
  1156.                            set("\x01",eval("\x01") - 234);
  1157.                            if(┬º┬ºpop())
  1158.                            {
  1159.                               set("\x01",eval("\x01") + 236);
  1160.                            }
  1161.                            continue;
  1162.                         }
  1163.                         if(eval("\x01") == 948)
  1164.                         {
  1165.                            set("\x01",eval("\x01") - 200);
  1166.                            if(┬º┬ºpop())
  1167.                            {
  1168.                               set("\x01",eval("\x01") - 459);
  1169.                            }
  1170.                            continue;
  1171.                         }
  1172.                         if(eval("\x01") == 640)
  1173.                         {
  1174.                            set("\x01",eval("\x01") - 327);
  1175.                            continue;
  1176.                         }
  1177.                         if(eval("\x01") == 35)
  1178.                         {
  1179.                            set("\x01",eval("\x01") + 141);
  1180.                            ┬º┬ºpush(true);
  1181.                            continue;
  1182.                         }
  1183.                         if(eval("\x01") == 560)
  1184.                         {
  1185.                            set("\x01",eval("\x01") + 388);
  1186.                            ┬º┬ºpush(true);
  1187.                            continue;
  1188.                         }
  1189.                         if(eval("\x01") == 266)
  1190.                         {
  1191.                            set("\x01",eval("\x01") + 267);
  1192.                            break loop0;
  1193.                         }
  1194.                         if(eval("\x01") == 641)
  1195.                         {
  1196.                            set("\x01",eval("\x01") - 375);
  1197.                            if(┬º┬ºpop())
  1198.                            {
  1199.                               set("\x01",eval("\x01") + 267);
  1200.                            }
  1201.                            continue;
  1202.                         }
  1203.                         if(eval("\x01") == 998)
  1204.                         {
  1205.                            set("\x01",eval("\x01") - 516);
  1206.                            ┬º┬ºpush(true);
  1207.                            continue;
  1208.                         }
  1209.                         if(eval("\x01") != 352)
  1210.                         {
  1211.                            if(eval("\x01") == 755)
  1212.                            {
  1213.                               set("\x01",eval("\x01") - 195);
  1214.                            }
  1215.                            else
  1216.                            {
  1217.                               if(eval("\x01") != 966)
  1218.                               {
  1219.                                  break loop0;
  1220.                               }
  1221.                               set("\x01",eval("\x01") - 152);
  1222.                            }
  1223.                            continue;
  1224.                         }
  1225.                         set("\x01",eval("\x01") - 352);
  1226.                      }
  1227.                   }
  1228.                }
  1229.             }
  1230.             break;
  1231.          }
  1232.          set("\x01",eval("\x01") - 117);
  1233.          ┬º┬ºpush(true);
  1234.       }
  1235.       continue;
  1236.    }
  1237.    set("\x01",eval("\x01") + 463);
  1238.    ┬º┬ºpush(┬º┬ºpop() or ┬º┬ºpop());
  1239.    while(true)
  1240.    {
  1241.       set("\x01",eval("\x01") + 520);
  1242.       do
  1243.       {
  1244.          while(true)
  1245.          {
  1246.             if(eval("\x01") == 394)
  1247.             {
  1248.                set("\x01",eval("\x01") - 370);
  1249.                ┬º┬ºpush(true);
  1250.             }
  1251.             else if(eval("\x01") == 243)
  1252.             {
  1253.                set("\x01",eval("\x01") - 110);
  1254.             }
  1255.             else if(eval("\x01") == 995)
  1256.             {
  1257.                set("\x01",eval("\x01") - 460);
  1258.             }
  1259.             else
  1260.             {
  1261.                if(eval("\x01") == 859)
  1262.                {
  1263.                   break;
  1264.                }
  1265.                if(eval("\x01") == 380)
  1266.                {
  1267.                   set("\x01",eval("\x01") + 155);
  1268.                }
  1269.                else if(eval("\x01") == 81)
  1270.                {
  1271.                   set("\x01",eval("\x01") + 220);
  1272.                }
  1273.                else if(eval("\x01") == 215)
  1274.                {
  1275.                   set("\x01",eval("\x01") + 715);
  1276.                   ┬º┬ºpush(true);
  1277.                }
  1278.                else if(eval("\x01") == 24)
  1279.                {
  1280.                   set("\x01",eval("\x01") + 796);
  1281.                   if(┬º┬ºpop())
  1282.                   {
  1283.                      set("\x01",eval("\x01") + 68);
  1284.                   }
  1285.                }
  1286.                else
  1287.                {
  1288.                   if(eval("\x01") == 49)
  1289.                   {
  1290.                      set("\x01",eval("\x01") + 341);
  1291.                      if(┬º┬ºpop())
  1292.                      {
  1293.                      }
  1294.                      break loop0;
  1295.                   }
  1296.                   if(eval("\x01") == 281)
  1297.                   {
  1298.                      set("\x01",eval("\x01") + 714);
  1299.                      break loop0;
  1300.                   }
  1301.                   if(eval("\x01") == 390)
  1302.                   {
  1303.                      set("\x01",eval("\x01") - 245);
  1304.                   }
  1305.                   else if(eval("\x01") == 345)
  1306.                   {
  1307.                      set("\x01",eval("\x01") - 130);
  1308.                   }
  1309.                   else if(eval("\x01") == 98)
  1310.                   {
  1311.                      set("\x01",eval("\x01") + 489);
  1312.                   }
  1313.                   else if(eval("\x01") == 727)
  1314.                   {
  1315.                      set("\x01",eval("\x01") - 724);
  1316.                   }
  1317.                   else if(eval("\x01") == 607)
  1318.                   {
  1319.                      set("\x01",eval("\x01") - 510);
  1320.                      if(┬º┬ºpop())
  1321.                      {
  1322.                         set("\x01",eval("\x01") + 160);
  1323.                      }
  1324.                   }
  1325.                   else
  1326.                   {
  1327.                      if(eval("\x01") == 0)
  1328.                      {
  1329.                         set("\x01",eval("\x01") + 421);
  1330.                         addr1660:
  1331.                         if(!┬º┬ºpop())
  1332.                         {
  1333.                            set("\x01",eval("\x01") - 564);
  1334.                            while(true)
  1335.                            {
  1336.                               if(eval("\x01") == 940)
  1337.                               {
  1338.                                  set("\x01",eval("\x01") - 911);
  1339.                                  ┬º┬ºpush(true);
  1340.                                  continue;
  1341.                               }
  1342.                               if(eval("\x01") == 418)
  1343.                               {
  1344.                                  set("\x01",eval("\x01") + 359);
  1345.                                  ┬º┬ºenumerate(┬º┬ºpop() instanceof ┬º┬ºpop());
  1346.                                  var ┬º┬ºenumeration();
  1347.                                  if(┬º┬ºpop())
  1348.                                  {
  1349.                                  }
  1350.                                  break loop0;
  1351.                               }
  1352.                               if(eval("\x01") == 950)
  1353.                               {
  1354.                                  set("\x01",eval("\x01") - 541);
  1355.                                  if(┬º┬ºpop())
  1356.                                  {
  1357.                                     set("\x01",eval("\x01") + 507);
  1358.                                  }
  1359.                                  continue;
  1360.                               }
  1361.                               if(eval("\x01") == 969)
  1362.                               {
  1363.                                  set("\x01",eval("\x01") - 836);
  1364.                                  ┬º┬ºpush(true);
  1365.                                  continue;
  1366.                               }
  1367.                               if(eval("\x01") == 777)
  1368.                               {
  1369.                                  set("\x01",eval("\x01") - 523);
  1370.                                  continue;
  1371.                               }
  1372.                               if(eval("\x01") == 556)
  1373.                               {
  1374.                                  set("\x01",eval("\x01") - 159);
  1375.                                  continue;
  1376.                               }
  1377.                               if(eval("\x01") == 51)
  1378.                               {
  1379.                                  set("\x01",eval("\x01") + 522);
  1380.                                  continue;
  1381.                               }
  1382.                               if(eval("\x01") == 262)
  1383.                               {
  1384.                                  set("\x01",eval("\x01") - 188);
  1385.                                  if(┬º┬ºpop())
  1386.                                  {
  1387.                                     set("\x01",eval("\x01") + 676);
  1388.                                  }
  1389.                                  continue;
  1390.                               }
  1391.                               if(eval("\x01") == 133)
  1392.                               {
  1393.                                  set("\x01",eval("\x01") + 106);
  1394.                                  if(┬º┬ºpop())
  1395.                                  {
  1396.                                     set("\x01",eval("\x01") + 456);
  1397.                                  }
  1398.                                  continue;
  1399.                               }
  1400.                               if(eval("\x01") == 916)
  1401.                               {
  1402.                                  set("\x01",eval("\x01") - 615);
  1403.                                  continue;
  1404.                               }
  1405.                               if(eval("\x01") == 95)
  1406.                               {
  1407.                                  set("\x01",eval("\x01") + 99);
  1408.                                  eval("π¡ƒdS{invalid_utf8=142}{invalid_utf8=254}\x16")[┬º┬ºconstant(2)][┬º┬ºconstant(3)]("{invalid_utf8=240}&3{invalid_utf8=167} {invalid_utf8=222}");
  1409.                                  gotoAndStop("Start");
  1410.                                  play();
  1411.                                  eval("π¡ƒdS{invalid_utf8=142}{invalid_utf8=254}\x16")[┬º┬ºconstant(6)](┬º┬ºconstant(5),┬º┬ºconstant(4));
  1412.                                  break loop0;
  1413.                               }
  1414.                               if(eval("\x01") == 259)
  1415.                               {
  1416.                                  set("\x01",eval("\x01") + 3);
  1417.                                  ┬º┬ºpush(true);
  1418.                                  continue;
  1419.                               }
  1420.                               if(eval("\x01") == 301)
  1421.                               {
  1422.                                  set("\x01",eval("\x01") + 332);
  1423.                                  ┬º┬ºpush(true);
  1424.                                  continue;
  1425.                               }
  1426.                               if(eval("\x01") == 461)
  1427.                               {
  1428.                                  set("\x01",eval("\x01") - 160);
  1429.                                  continue;
  1430.                               }
  1431.                               if(eval("\x01") == 633)
  1432.                               {
  1433.                                  set("\x01",eval("\x01") + 340);
  1434.                                  if(┬º┬ºpop())
  1435.                                  {
  1436.                                     set("\x01",eval("\x01") - 540);
  1437.                                  }
  1438.                                  continue;
  1439.                               }
  1440.                               if(eval("\x01") == 254)
  1441.                               {
  1442.                                  set("\x01",eval("\x01") - 159);
  1443.                                  continue;
  1444.                               }
  1445.                               if(eval("\x01") == 164)
  1446.                               {
  1447.                                  set("\x01",eval("\x01") + 254);
  1448.                                  if(┬º┬ºpop())
  1449.                                  {
  1450.                                     set("\x01",eval("\x01") + 359);
  1451.                                  }
  1452.                                  continue;
  1453.                               }
  1454.                               if(eval("\x01") == 409)
  1455.                               {
  1456.                                  set("\x01",eval("\x01") + 507);
  1457.                                  break loop0;
  1458.                               }
  1459.                               if(eval("\x01") == 523)
  1460.                               {
  1461.                                  set("\x01",eval("\x01") + 38);
  1462.                                  if(┬º┬ºpop())
  1463.                                  {
  1464.                                     set("\x01",eval("\x01") - 5);
  1465.                                  }
  1466.                                  continue;
  1467.                               }
  1468.                               if(eval("\x01") == 239)
  1469.                               {
  1470.                                  set("\x01",eval("\x01") + 456);
  1471.                                  break loop0;
  1472.                               }
  1473.                               if(eval("\x01") == 561)
  1474.                               {
  1475.                                  set("\x01",eval("\x01") - 5);
  1476.                                  break loop0;
  1477.                               }
  1478.                               ┬º┬ºgoto(addr1660);
  1479.                               ┬º┬ºpush(eval("\x01") != 823);
  1480.                            }
  1481.                            addr1830:
  1482.                            ┬º┬ºpush(eval("\x01"));
  1483.                            ┬º┬ºpush(750);
  1484.                            while(true)
  1485.                            {
  1486.                               if(┬º┬ºpop() == ┬º┬ºpop())
  1487.                               {
  1488.                                  set("\x01",eval("\x01") - 748);
  1489.                               }
  1490.                               else if(eval("\x01") == 86)
  1491.                               {
  1492.                                  set("\x01",eval("\x01") + 311);
  1493.                               }
  1494.                               else
  1495.                               {
  1496.                                  if(eval("\x01") == 291)
  1497.                                  {
  1498.                                     set("\x01",eval("\x01") - 240);
  1499.                                     break loop0;
  1500.                                  }
  1501.                                  if(eval("\x01") == 973)
  1502.                                  {
  1503.                                     break;
  1504.                                  }
  1505.                                  if(eval("\x01") == 74)
  1506.                                  {
  1507.                                     set("\x01",eval("\x01") + 676);
  1508.                                     break loop0;
  1509.                                  }
  1510.                                  if(eval("\x01") == 433)
  1511.                                  {
  1512.                                     set("\x01",eval("\x01") + 536);
  1513.                                  }
  1514.                                  else if(eval("\x01") == 506)
  1515.                                  {
  1516.                                     set("\x01",eval("\x01") + 463);
  1517.                                  }
  1518.                                  else
  1519.                                  {
  1520.                                     if(eval("\x01") == 668)
  1521.                                     {
  1522.                                        set("\x01",eval("\x01") - 230);
  1523.                                        play();
  1524.                                        ┬º┬ºpush(┬º┬ºpop() or ┬º┬ºpop());
  1525.                                        break loop0;
  1526.                                     }
  1527.                                     if(eval("\x01") == 559)
  1528.                                     {
  1529.                                        set("\x01",eval("\x01") + 166);
  1530.                                     }
  1531.                                     else
  1532.                                     {
  1533.                                        if(eval("\x01") == 588)
  1534.                                        {
  1535.                                           set("\x01",eval("\x01") + 170);
  1536.                                           ┬º┬ºpush(┬º┬ºpop() + ┬º┬ºpop());
  1537.                                           break loop0;
  1538.                                        }
  1539.                                        if(eval("\x01") == 845)
  1540.                                        {
  1541.                                           set("\x01",eval("\x01") - 257);
  1542.                                           if(┬º┬ºpop())
  1543.                                           {
  1544.                                              set("\x01",eval("\x01") + 170);
  1545.                                           }
  1546.                                        }
  1547.                                        else if(eval("\x01") == 573)
  1548.                                        {
  1549.                                           set("\x01",eval("\x01") + 272);
  1550.                                           ┬º┬ºpush(true);
  1551.                                        }
  1552.                                        else if(eval("\x01") == 645)
  1553.                                        {
  1554.                                           set("\x01",eval("\x01") - 354);
  1555.                                           if(┬º┬ºpop())
  1556.                                           {
  1557.                                              set("\x01",eval("\x01") - 240);
  1558.                                           }
  1559.                                        }
  1560.                                        else if(eval("\x01") == 725)
  1561.                                        {
  1562.                                           set("\x01",eval("\x01") - 80);
  1563.                                           ┬º┬ºpush(true);
  1564.                                        }
  1565.                                        else
  1566.                                        {
  1567.                                           if(eval("\x01") != 438)
  1568.                                           {
  1569.                                              break loop0;
  1570.                                           }
  1571.                                           set("\x01",eval("\x01") + 287);
  1572.                                        }
  1573.                                     }
  1574.                                  }
  1575.                               }
  1576.                               ┬º┬ºgoto(addr1312);
  1577.                               ┬º┬ºgoto(addr1830);
  1578.                            }
  1579.                            addr1312:
  1580.                            set("\x01",eval("\x01") - 540);
  1581.                            return ┬º┬ºpop() >>> ┬º┬ºpop();
  1582.                            addr1833:
  1583.                         }
  1584.                         if(eval("\x01") == 695)
  1585.                         {
  1586.                            set("\x01",eval("\x01") + 62);
  1587.                            ┬º┬ºgoto(addr1830);
  1588.                         }
  1589.                         if(eval("\x01") == 639)
  1590.                         {
  1591.                            set("\x01",eval("\x01") - 637);
  1592.                            ┬º┬ºgoto(addr1830);
  1593.                         }
  1594.                         if(eval("\x01") == 237)
  1595.                         {
  1596.                            set("\x01",eval("\x01") + 17);
  1597.                            ┬º┬ºgoto(addr1830);
  1598.                         }
  1599.                         if(eval("\x01") != 194)
  1600.                         {
  1601.                            if(eval("\x01") == 758)
  1602.                            {
  1603.                               set("\x01",eval("\x01") - 499);
  1604.                               ┬º┬ºgoto(addr1830);
  1605.                            }
  1606.                            if(eval("\x01") == 757)
  1607.                            {
  1608.                               set("\x01",eval("\x01") - 593);
  1609.                               ┬º┬ºgoto(addr1830);
  1610.                               ┬º┬ºpush(true);
  1611.                            }
  1612.                            if(eval("\x01") == 303)
  1613.                            {
  1614.                               set("\x01",eval("\x01") + 454);
  1615.                               ┬º┬ºgoto(addr1830);
  1616.                            }
  1617.                            if(eval("\x01") == 2)
  1618.                            {
  1619.                               set("\x01",eval("\x01") + 521);
  1620.                               ┬º┬ºgoto(addr1830);
  1621.                               ┬º┬ºpush(true);
  1622.                            }
  1623.                            if(eval("\x01") == 204)
  1624.                            {
  1625.                               set("\x01",eval("\x01") + 369);
  1626.                               ┬º┬ºgoto(addr1830);
  1627.                            }
  1628.                            if(eval("\x01") == 29)
  1629.                            {
  1630.                               set("\x01",eval("\x01") + 639);
  1631.                               if(!┬º┬ºpop())
  1632.                               {
  1633.                                  addr1815:
  1634.                                  ┬º┬ºgoto(addr1830);
  1635.                               }
  1636.                               set("\x01",eval("\x01") - 230);
  1637.                               ┬º┬ºgoto(addr1815);
  1638.                            }
  1639.                            if(eval("\x01") == 397)
  1640.                            {
  1641.                               set("\x01",eval("\x01") + 553);
  1642.                               ┬º┬ºgoto(addr1830);
  1643.                               ┬º┬ºpush(true);
  1644.                            }
  1645.                            ┬º┬ºgoto(addr1830);
  1646.                         }
  1647.                         set("\x01",eval("\x01") - 194);
  1648.                         break loop0;
  1649.                      }
  1650.                      if(eval("\x01") == 613)
  1651.                      {
  1652.                         set("\x01",eval("\x01") - 374);
  1653.                         ┬º┬ºpush(┬º┬ºpop() add ┬º┬ºpop());
  1654.                         break loop0;
  1655.                      }
  1656.                      if(eval("\x01") == 421)
  1657.                      {
  1658.                         set("\x01",eval("\x01") - 418);
  1659.                      }
  1660.                      else if(eval("\x01") == 999)
  1661.                      {
  1662.                         set("\x01",eval("\x01") - 950);
  1663.                         if(┬º┬ºpop())
  1664.                         {
  1665.                            set("\x01",eval("\x01") + 341);
  1666.                         }
  1667.                      }
  1668.                      else if(eval("\x01") == 648)
  1669.                      {
  1670.                         set("\x01",eval("\x01") - 648);
  1671.                         if(┬º┬ºpop())
  1672.                         {
  1673.                            set("\x01",eval("\x01") + 421);
  1674.                         }
  1675.                      }
  1676.                      else if(eval("\x01") == 535)
  1677.                      {
  1678.                         set("\x01",eval("\x01") + 113);
  1679.                         ┬º┬ºpush(true);
  1680.                      }
  1681.                      else if(eval("\x01") == 133)
  1682.                      {
  1683.                         set("\x01",eval("\x01") + 596);
  1684.                         ┬º┬ºpush(true);
  1685.                      }
  1686.                      else if(eval("\x01") == 729)
  1687.                      {
  1688.                         set("\x01",eval("\x01") - 192);
  1689.                         if(┬º┬ºpop())
  1690.                         {
  1691.                            set("\x01",eval("\x01") - 97);
  1692.                         }
  1693.                      }
  1694.                      else
  1695.                      {
  1696.                         if(eval("\x01") == 820)
  1697.                         {
  1698.                            set("\x01",eval("\x01") + 68);
  1699.                            break loop0;
  1700.                         }
  1701.                         if(eval("\x01") == 587)
  1702.                         {
  1703.                            set("\x01",eval("\x01") + 412);
  1704.                            ┬º┬ºpush(true);
  1705.                         }
  1706.                         else if(eval("\x01") == 888)
  1707.                         {
  1708.                            set("\x01",eval("\x01") - 755);
  1709.                         }
  1710.                         else
  1711.                         {
  1712.                            if(eval("\x01") == 537)
  1713.                            {
  1714.                               set("\x01",eval("\x01") - 97);
  1715.                               break loop0;
  1716.                            }
  1717.                            if(eval("\x01") == 454)
  1718.                            {
  1719.                               set("\x01",eval("\x01") + 520);
  1720.                               var _loc226_ = null;
  1721.                               ┬º┬ºpush(_loc226_ = ┬º┬ºpop() / ┬º┬ºpop());
  1722.                               break loop0;
  1723.                            }
  1724.                            if(eval("\x01") == 440)
  1725.                            {
  1726.                               set("\x01",eval("\x01") - 139);
  1727.                            }
  1728.                            else
  1729.                            {
  1730.                               if(eval("\x01") == 3)
  1731.                               {
  1732.                                  set("\x01",eval("\x01") + 82);
  1733.                                  gotoAndPlay(_root.randInt(1,this._totalframes));
  1734.                                  break loop0;
  1735.                               }
  1736.                               if(eval("\x01") == 636)
  1737.                               {
  1738.                                  set("\x01",eval("\x01") - 536);
  1739.                               }
  1740.                               else if(eval("\x01") == 936)
  1741.                               {
  1742.                                  set("\x01",eval("\x01") - 120);
  1743.                               }
  1744.                               else
  1745.                               {
  1746.                                  if(eval("\x01") == 85)
  1747.                                  {
  1748.                                     set("\x01",eval("\x01") - 85);
  1749.                                     break loop0;
  1750.                                  }
  1751.                                  if(eval("\x01") == 301)
  1752.                                  {
  1753.                                     set("\x01",eval("\x01") + 306);
  1754.                                     ┬º┬ºpush(true);
  1755.                                  }
  1756.                                  else
  1757.                                  {
  1758.                                     if(eval("\x01") == 97)
  1759.                                     {
  1760.                                        set("\x01",eval("\x01") + 160);
  1761.                                        while(true)
  1762.                                        {
  1763.                                           if(┬º┬ºpop() == ┬º┬ºpop())
  1764.                                           {
  1765.                                              set("\x01",eval("\x01") - 78);
  1766.                                              if(┬º┬ºpop())
  1767.                                              {
  1768.                                                 set("\x01",eval("\x01") + 9);
  1769.                                              }
  1770.                                              continue;
  1771.                                           }
  1772.                                           if(eval("\x01") == 617)
  1773.                                           {
  1774.                                              set("\x01",eval("\x01") - 58);
  1775.                                              continue;
  1776.                                           }
  1777.                                           if(eval("\x01") == 895)
  1778.                                           {
  1779.                                              set("\x01",eval("\x01") - 677);
  1780.                                              continue;
  1781.                                           }
  1782.                                           if(eval("\x01") == 215)
  1783.                                           {
  1784.                                              set("\x01",eval("\x01") + 9);
  1785.                                              break loop0;
  1786.                                           }
  1787.                                           if(eval("\x01") == 352)
  1788.                                           {
  1789.                                              set("\x01",eval("\x01") + 565);
  1790.                                              ┬º┬ºpush(true);
  1791.                                              continue;
  1792.                                           }
  1793.                                           if(eval("\x01") == 926)
  1794.                                           {
  1795.                                              set("\x01",eval("\x01") - 100);
  1796.                                              stopDrag();
  1797.                                              ┬º┬ºpush(chr(┬º┬ºpop()));
  1798.                                              break loop0;
  1799.                                           }
  1800.                                           if(eval("\x01") == 95)
  1801.                                           {
  1802.                                              set("\x01",eval("\x01") + 198);
  1803.                                              ┬º┬ºpush(true);
  1804.                                              continue;
  1805.                                           }
  1806.                                           if(eval("\x01") == 878)
  1807.                                           {
  1808.                                              set("\x01",eval("\x01") - 533);
  1809.                                              ┬º┬ºpop() extends ┬º┬ºpop() gt ┬º┬ºpop();
  1810.                                              break loop0;
  1811.                                           }
  1812.                                           if(eval("\x01") != 794)
  1813.                                           {
  1814.                                              if(eval("\x01") == 646)
  1815.                                              {
  1816.                                                 set("\x01",eval("\x01") + 98);
  1817.                                              }
  1818.                                              else if(eval("\x01") == 328)
  1819.                                              {
  1820.                                                 set("\x01",eval("\x01") + 231);
  1821.                                              }
  1822.                                              else if(eval("\x01") == 917)
  1823.                                              {
  1824.                                                 set("\x01",eval("\x01") - 578);
  1825.                                                 if(┬º┬ºpop())
  1826.                                                 {
  1827.                                                    set("\x01",eval("\x01") - 105);
  1828.                                                 }
  1829.                                              }
  1830.                                              else if(eval("\x01") == 145)
  1831.                                              {
  1832.                                                 set("\x01",eval("\x01") + 649);
  1833.                                                 if(┬º┬ºpop())
  1834.                                                 {
  1835.                                                    set("\x01",eval("\x01") - 177);
  1836.                                                 }
  1837.                                              }
  1838.                                              else if(eval("\x01") == 345)
  1839.                                              {
  1840.                                                 set("\x01",eval("\x01") - 127);
  1841.                                              }
  1842.                                              else if(eval("\x01") == 360)
  1843.                                              {
  1844.                                                 set("\x01",eval("\x01") - 247);
  1845.                                              }
  1846.                                              else if(eval("\x01") == 920)
  1847.                                              {
  1848.                                                 set("\x01",eval("\x01") - 825);
  1849.                                              }
  1850.                                              else if(eval("\x01") == 775)
  1851.                                              {
  1852.                                                 set("\x01",eval("\x01") + 103);
  1853.                                                 if(┬º┬ºpop())
  1854.                                                 {
  1855.                                                    set("\x01",eval("\x01") - 533);
  1856.                                                 }
  1857.                                              }
  1858.                                              else if(eval("\x01") == 227)
  1859.                                              {
  1860.                                                 set("\x01",eval("\x01") + 125);
  1861.                                              }
  1862.                                              else
  1863.                                              {
  1864.                                                 if(eval("\x01") == 744)
  1865.                                                 {
  1866.                                                    set("\x01",eval("\x01") + 137);
  1867.                                                    gotoAndPlay(_root.randInt(1,this._totalframes));
  1868.                                                    break loop0;
  1869.                                                 }
  1870.                                                 if(eval("\x01") == 218)
  1871.                                                 {
  1872.                                                    set("\x01",eval("\x01") + 249);
  1873.                                                    ┬º┬ºpush(true);
  1874.                                                 }
  1875.                                                 else if(eval("\x01") == 467)
  1876.                                                 {
  1877.                                                    set("\x01",eval("\x01") + 459);
  1878.                                                    if(┬º┬ºpop())
  1879.                                                    {
  1880.                                                       set("\x01",eval("\x01") - 100);
  1881.                                                    }
  1882.                                                 }
  1883.                                                 else
  1884.                                                 {
  1885.                                                    if(eval("\x01") == 339)
  1886.                                                    {
  1887.                                                       set("\x01",eval("\x01") - 105);
  1888.                                                       ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1889.                                                       break loop0;
  1890.                                                    }
  1891.                                                    if(eval("\x01") == 609)
  1892.                                                    {
  1893.                                                       set("\x01",eval("\x01") + 170);
  1894.                                                       if(┬º┬ºpop())
  1895.                                                       {
  1896.                                                          set("\x01",eval("\x01") - 133);
  1897.                                                       }
  1898.                                                    }
  1899.                                                    else if(eval("\x01") == 234)
  1900.                                                    {
  1901.                                                       set("\x01",eval("\x01") - 139);
  1902.                                                    }
  1903.                                                    else if(eval("\x01") == 224)
  1904.                                                    {
  1905.                                                       set("\x01",eval("\x01") - 111);
  1906.                                                    }
  1907.                                                    else
  1908.                                                    {
  1909.                                                       if(eval("\x01") == 779)
  1910.                                                       {
  1911.                                                          set("\x01",eval("\x01") - 133);
  1912.                                                          ┬º┬ºpush(┬º┬ºpop() | ┬º┬ºpop());
  1913.                                                          break loop0;
  1914.                                                       }
  1915.                                                       if(eval("\x01") != 989)
  1916.                                                       {
  1917.                                                          if(eval("\x01") == 881)
  1918.                                                          {
  1919.                                                             set("\x01",eval("\x01") - 881);
  1920.                                                          }
  1921.                                                          break loop0;
  1922.                                                       }
  1923.                                                       set("\x01",eval("\x01") - 245);
  1924.                                                    }
  1925.                                                 }
  1926.                                              }
  1927.                                              continue;
  1928.                                           }
  1929.                                           set("\x01",eval("\x01") - 177);
  1930.                                        }
  1931.                                     }
  1932.                                     else
  1933.                                     {
  1934.                                        if(eval("\x01") == 323)
  1935.                                        {
  1936.                                           set("\x01",eval("\x01") - 42);
  1937.                                           if(┬º┬ºpop())
  1938.                                           {
  1939.                                              set("\x01",eval("\x01") + 714);
  1940.                                           }
  1941.                                           continue;
  1942.                                        }
  1943.                                        if(eval("\x01") == 145)
  1944.                                        {
  1945.                                           set("\x01",eval("\x01") + 714);
  1946.                                           ┬º┬ºpush(true);
  1947.                                           continue;
  1948.                                        }
  1949.                                        if(eval("\x01") == 974)
  1950.                                        {
  1951.                                           set("\x01",eval("\x01") - 874);
  1952.                                           continue;
  1953.                                        }
  1954.                                        if(eval("\x01") == 816)
  1955.                                        {
  1956.                                           set("\x01",eval("\x01") - 493);
  1957.                                           ┬º┬ºpush(true);
  1958.                                           continue;
  1959.                                        }
  1960.                                        if(eval("\x01") == 503)
  1961.                                        {
  1962.                                           set("\x01",eval("\x01") + 313);
  1963.                                           continue;
  1964.                                        }
  1965.                                        if(eval("\x01") == 506)
  1966.                                        {
  1967.                                           set("\x01",eval("\x01") - 361);
  1968.                                           continue;
  1969.                                        }
  1970.                                        if(eval("\x01") == 100)
  1971.                                        {
  1972.                                           set("\x01",eval("\x01") + 624);
  1973.                                           ┬º┬ºpush(true);
  1974.                                           continue;
  1975.                                        }
  1976.                                        if(eval("\x01") == 257)
  1977.                                        {
  1978.                                           set("\x01",eval("\x01") - 42);
  1979.                                           continue;
  1980.                                        }
  1981.                                     }
  1982.                                     if(eval("\x01") == 239)
  1983.                                     {
  1984.                                        set("\x01",eval("\x01") + 348);
  1985.                                     }
  1986.                                     else if(eval("\x01") == 930)
  1987.                                     {
  1988.                                        set("\x01",eval("\x01") - 317);
  1989.                                        if(┬º┬ºpop())
  1990.                                        {
  1991.                                           set("\x01",eval("\x01") - 374);
  1992.                                        }
  1993.                                     }
  1994.                                     else
  1995.                                     {
  1996.                                        if(eval("\x01") != 724)
  1997.                                        {
  1998.                                           if(eval("\x01") == 307)
  1999.                                           {
  2000.                                              set("\x01",eval("\x01") + 196);
  2001.                                              gotoAndStop("{invalid_utf8=138}@\x02X{invalid_utf8=132}");
  2002.                                           }
  2003.                                           break loop0;
  2004.                                        }
  2005.                                        set("\x01",eval("\x01") - 417);
  2006.                                        if(┬º┬ºpop())
  2007.                                        {
  2008.                                           set("\x01",eval("\x01") + 196);
  2009.                                        }
  2010.                                     }
  2011.                                  }
  2012.                               }
  2013.                            }
  2014.                         }
  2015.                      }
  2016.                   }
  2017.                }
  2018.             }
  2019.          }
  2020.          set("\x01",eval("\x01") - 405);
  2021.       }
  2022.       while(!┬º┬ºpop());
  2023.       
  2024.    }
  2025.    ┬º┬ºgoto(addr1833);
  2026. }
  2027.